/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package moteur.carte.editor;

import java.util.logging.Level;
import java.util.logging.Logger;
import moteur.carte.*;
import java.util.Vector;
import java.io.File;
import javax.swing.*;


/**
 *
 * @author sdecrem
 */

// Pour serialization attributs sans static et constructeur public

public class Graphe {
     /**
      * Création de l'instance au niveau de la variable.
      */
     //private static final Graphe instance = new Graphe();
     public static int nbMaxChemin =  10;
     /**
      *
      */
     public static int nbMaxVille = 14 ;
     /**
      *
      */
     public static int nbMaxRiviere = 3 ;
     /**
      *
      */
     public static int nbMaxLac = 2 ;
     /**
      * Conteneur de chemin
      */
     private Vector<Chemin> listeChemin= new Vector() ;
     /**
      * Conteneur de ville
      */
     private Vector<Ville> listeVille = new Vector() ;
     /**
      * Conteneur de riviere
      */
     private Vector<Riviere> listeRiviere = new Vector() ;
     /**
      * Conteneur de lac
      */
     private Vector<Lac> listeLac = new Vector() ;
     /**
      * La capitale
      */
     private Capitale capitale = new Capitale() ;

     /**
      * La présence d'un constructeur privé supprime
      * le constructeur public par défaut.
      */
     public Graphe() {}

     /** Retourne l'instance du singleton.
      * @return
      */
     public final Graphe getInstance() {
         //return instance;
         return this;
     }

     /**
      * Demande à l'utilisateur son choix pour la map à afficher
      * @return
      * le nom du fichier qui doit être placé dans un répertoire précis
      */
     public final static String mapChoice() {
         // TODO : demander la map avec un choix par defaut
         File temp = new File("") ;
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File(temp.getAbsolutePath()+File.separator+"src"+File.separator));
         //xmlFilter filter = new xmlFilter() ;
         //chooser.setFileFilter(filter);
         int returnVal = chooser.showOpenDialog(chooser);
         if (returnVal == JFileChooser.APPROVE_OPTION)
             return chooser.getSelectedFile().getAbsolutePath() ;
         return "" ;
     }

     /**
      * Parsage du fichier xml pour vérifier que les informations contenues sont valides.
      * @param filename
      * Le fichier qui sera parsé.
      * @return
      * Un boolean qui sera True si la map est valide et False dans le cas contraire.
      */
     //private final static boolean checkIntegrityMap(String filename) {
         // TODO : parsage du fichier pour vérifier qu'il y a :
         // les 20 villes (dont une capitale) / les sommets / les lacs / les rivières

         // nico dit: faudrait juste vérifier que chaque ville a 2 à 5 "roads",
         // et que toutes les "roads" menent à une ville existante.
         //return false ;
     //}

    /* DEROULEMENT */
     // definir si on utilise une carte par defaut ou non       mapChoice() ;
     // parsage de l'intégrité de la map (si pas logique passer au choix par défaut en prévenant l'user) checkIntegrityMap(String filename) ;
     // si la carte est "intègre" chargement de la carte par    this.read("fichier.xml") ;
     // le chargement restorera :
     //                             - les 20 villes (dont une capitale)
     //                             - les sommets
     //                             - les lacs
     //                             - les rivières

    /**
     *
     * @param c
     */
    public void addChemin(Chemin c) {
        listeChemin.addElement(c) ;
    }

    /**
     *
     * @param v
     */
    public void setListeChemin(Vector<Chemin> v) {
        listeChemin = v;
    }

    /**
     *
     * @param n
     * @return
     */
    public Chemin getChemin(int n) {
        return listeChemin.elementAt(n) ;
    }

    /**
     *
     * @return
     */
    public Vector<Chemin> getListeChemin() {
        return listeChemin ;
    }

    /**
     *
     * @param v
     */
    public void addVille(Ville v) {
        listeVille.addElement(v);
    }

    /**
     *
     * @param v
     */
    public void setListeVille(Vector<Ville> v) {
        listeVille = v ;
    }

    /**
     *
     * @param n
     * @return
     */
    public Ville getVille(int n) {
        return listeVille.elementAt(n) ;
    }

    /**
     *
     * @return
     */
    public Vector<Ville> getListeVille() {
        return listeVille ;
    }

    /**
     *
     * @param r
     */
    public void addRiviere(Riviere r) {
        listeRiviere.addElement(r) ;
    }

    /**
     *
     * @param v
     */
    public void setListeRiviere(Vector<Riviere> v) {
        listeRiviere = v ;
    }

    /**
     *
     * @param n
     * @return
     */
    public Riviere getRiviere(int n) {
        return listeRiviere.elementAt(n) ;
    }

    /**
     *
     * @return
     */
    public Vector<Riviere> getListeRiviere() {
        return listeRiviere ;
    }

    /**
     *
     * @param l
     */
    public void addLac(Lac l) {
        listeLac.addElement(l) ;
    }

    /**
     *
     * @param v
     */
    public void setListeLac(Vector<Lac> v) {
        listeLac = v ;
    }

    /**
     *
     * @param n
     * @return
     */
    public Lac getLac(int n) {
        return listeLac.elementAt(n) ;
    }

    /**
     * 
     * @return
     */
    public Vector<Lac> getListeLac() {
        return listeLac ;
    }

    /**
     * 
     * @param ca
     */
    public void setCapitale(Capitale ca) {
        capitale = ca ;
    }

    /**
     *
     * @return
     */
    public Capitale getCapitale() {
        return capitale ;
    }

    @Override
    public String toString() {
        StringBuffer affichage = new StringBuffer() ;

        for (Chemin chemin : listeChemin) {
            affichage.append(chemin) ;
        }
        affichage.append("\n") ;
        affichage.append(capitale);
        affichage.append("\n") ;
        for (Ville ville : listeVille) {
            affichage.append(ville) ;
        }
        affichage.append("\n") ;
        for (Riviere riviere : listeRiviere) {
            affichage.append(riviere) ;
        }
        affichage.append("\n") ;
        for (Lac lac : listeLac) {
            affichage.append(lac) ;
        }
        affichage.append("\n") ;

        return affichage.toString() ;
    }

    public static void writeGraphe(String file) {
        ControllerGraphe cg = new ControllerGraphe() ;
        try {
            cg.writeGraphe(file);
        } catch (Exception ex) {
            Logger.getLogger(Graphe.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Fonction qui se charge de la récupération des information, et la création des objets correspondant
     * @param grapheXml
     * @return
     */
    public static Graphe readGraphe(String grapheXml){
        ControllerGraphe cg = new ControllerGraphe() ;
        File temp = new File("") ;
        File the_file = new File(grapheXml) ;
        try {
            cg.readGraphe(the_file);
        } catch (Exception ex) {
            //System.err.println("bordel c'est encore le graphe qu'a merdé! but the graphe never fail !");
        } finally{
            return cg.getGraphe();
        }
    }

    public static Graphe readGraphe(){
        ControllerGraphe cg = new ControllerGraphe() ;
        try {
            cg.readGraphe();
        } catch (Exception ex) {
            //
        } finally{
            return cg.getGraphe();
        }
    }

    public static Graphe readGrapheAbs(String grapheXml){
        ControllerGraphe cg = new ControllerGraphe() ;
        File the_file = new File(grapheXml) ;
        try {
            cg.readGraphe(the_file);
        } catch (Exception ex) {
            cg.readGraphe() ;
        } finally{
            return cg.getGraphe();
        }
    }
}